#ifndef __VG_FWCREATIONPARAMETERS_H_INCLUDE__
#define __VG_FWCREATIONPARAMETERS_H_INCLUDE__
#include "vgTypes.h"
#include "rect.h"
#include "EDeviceTypes.h"
#include "EDriverTypes.h"

namespace vg
{
	namespace fw
	{
		class IEventReceiver;

		//! Structure for holding Irrlicht Device creation parameters.
		/** This structure is used in the createDeviceEx() function. */
		struct FWCreationParameters
		{
			//! Constructs a SIrrlichtCreationParameters structure with default values.
			FWCreationParameters() :
				DeviceType(EIDT_WIN32),
				WindowSize(core::dimension2d<u32>(800, 600)),
				Bits(16),
				ZBufferBits(16),
				Fullscreen(false),
				Stencilbuffer(false),
				Vsync(false),
				AntiAlias(0),
				EventReceiver(0),
				WithAlphaChannel(false),
				Doublebuffer(true),
				IgnoreInput(false),
				Stereobuffer(false),
				WindowId(0),
				Resizealbe(false),
				DriverType(EDT_HALFSOFTWARE)
				//	SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
			{
			}

			FWCreationParameters(const FWCreationParameters& other)
				//SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
			{
				*this = other;
			}

			FWCreationParameters& operator=(const FWCreationParameters& other)
			{
				DeviceType = other.DeviceType;
				WindowSize = other.WindowSize;
				Bits = other.Bits;
				ZBufferBits = other.ZBufferBits;
				Fullscreen = other.Fullscreen;
				Stencilbuffer = other.Stencilbuffer;
				Vsync = other.Vsync;
				AntiAlias = other.AntiAlias;
				WithAlphaChannel = other.WithAlphaChannel;
				Doublebuffer = other.Doublebuffer;
				IgnoreInput = other.IgnoreInput;
				EventReceiver = other.EventReceiver;
				Stereobuffer = other.Stereobuffer;
				WindowId = other.WindowId;
				DriverType = other.DriverType;
				Resizealbe = other.Resizealbe;
				return *this;
			}

			//! Type of the device.
			/** This setting decides the windowing system used by the device, most device types are native
			to a specific operating system and so may not be available.
			EIDT_WIN32 is only available on Windows desktops,
			EIDT_WINCE is only available on Windows mobile devices,
			EIDT_COCOA is only available on Mac OSX,
			EIDT_X11 is available on Linux, Solaris, BSD and other operating systems which use X11,
			EIDT_SDL is available on most systems if compiled in,
			EIDT_CONSOLE is usually available but can only render to text,
			EIDT_BEST will select the best available device for your operating system.
			Default: EIDT_BEST. */
			E_DEVICE_TYPE DeviceType;

			//! Size of the window or the video mode in fullscreen mode. Default: 800x600
			core::dimension2d<u32> WindowSize;

			//! Minimum Bits per pixel of the color buffer in fullscreen mode. Ignored if windowed mode. Default: 16.
			u8 Bits;

			//! Minimum Bits per pixel of the depth buffer. Default: 16.
			u8 ZBufferBits;

			//! Should be set to true if the device should run in fullscreen.
			/** Otherwise the device runs in windowed mode. Default: false. */
			bool Fullscreen;

			//! Specifies if the stencil buffer should be enabled.
			/** Set this to true, if you want the engine be able to draw
			stencil buffer shadows. Note that not all drivers are able to
			use the stencil buffer, hence it can be ignored during device
			creation. Without the stencil buffer no shadows will be drawn.
			Default: false. */
			bool Stencilbuffer;

			//! Specifies vertical syncronisation.
			/** If set to true, the driver will wait for the vertical
			retrace period, otherwise not. May be silently ignored.
			Default: false */
			bool Vsync;

			//! Specifies if the device should use fullscreen anti aliasing
			/** Makes sharp/pixelated edges softer, but requires more
			performance. Also, 2D elements might look blurred with this
			switched on. The resulting rendering quality also depends on
			the hardware and driver you are using, your program might look
			different on different hardware with this. So if you are
			writing a game/application with AntiAlias switched on, it would
			be a good idea to make it possible to switch this option off
			again by the user.
			The value is the maximal antialiasing factor requested for
			the device. The cretion method will automatically try smaller
			values if no window can be created with the given value.
			Value one is usually the same as 0 (disabled), but might be a
			special value on some platforms. On D3D devices it maps to
			NONMASKABLE.
			Default value: 0 - disabled */
			u8 AntiAlias;

			//! Whether the main framebuffer uses an alpha channel.
			/** In some situations it might be desireable to get a color
			buffer with an alpha channel, e.g. when rendering into a
			transparent window or overlay. If this flag is set the device
			tries to create a framebuffer with alpha channel.
			If this flag is set, only color buffers with alpha channel
			are considered. Otherwise, it depends on the actual hardware
			if the colorbuffer has an alpha channel or not.
			Default value: false */
			bool WithAlphaChannel;

			//! Whether the main framebuffer uses doublebuffering.
			/** This should be usually enabled, in order to avoid render
			artifacts on the visible framebuffer. However, it might be
			useful to use only one buffer on very small devices. If no
			doublebuffering is available, the drivers will fall back to
			single buffers. Default value: true */
			bool Doublebuffer;

			//! Specifies if the device should ignore input events
			/** This is only relevant when using external I/O handlers.
			External windows need to take care of this themselves.
			Currently only supported by X11.
			Default value: false */
			bool IgnoreInput;

			//! Specifies if the device should use stereo buffers
			/** Some high-end gfx cards support two framebuffers for direct
			support of stereoscopic output devices. If this flag is set the
			device tries to create a stereo context.
			Currently only supported by OpenGL.
			Default value: false */
			bool Stereobuffer;


			//! A user created event receiver.
			IEventReceiver* EventReceiver;

			E_DRIVER_TYPE DriverType;

			//! Window Id.
			/** If this is set to a value other than 0, the Irrlicht Engine
			will be created in an already existing window. For windows, set
			this to the HWND of the window you want. The windowSize and
			FullScreen options will be ignored when using the WindowId
			parameter. Default this is set to 0.
			To make Irrlicht run inside the custom window, you still will
			have to draw Irrlicht on your own. You can use this loop, as
			usual:
			\code
			while (device->run())
			{
			driver->beginScene(true, true, 0);
			smgr->drawAll();
			driver->endScene();
			}
			\endcode
			Instead of this, you can also simply use your own message loop
			using GetMessage, DispatchMessage and whatever. Calling
			IrrlichtDevice::run() will cause Irrlicht to dispatch messages
			internally too.  You need not call Device->run() if you want to
			do your own message dispatching loop, but Irrlicht will not be
			able to fetch user input then and you have to do it on your own
			using the window messages, DirectInput, or whatever. Also,
			you'll have to increment the Irrlicht timer.
			An alternative, own message dispatching loop without
			device->run() would look like this:
			\code
			MSG msg;
			while (true)
			{
			if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
			{
			TranslateMessage(&msg);
			DispatchMessage(&msg);

			if (msg.message == WM_QUIT)
			break;
			}

			// increase virtual timer time
			device->getTimer()->tick();

			// draw engine picture
			driver->beginScene(true, true, 0);
			smgr->drawAll();
			driver->endScene();
			}
			\endcode
			However, there is no need to draw the picture this often. Just
			do it how you like. */
			void* WindowId;

			bool Resizealbe;

		};

	}
}
#endif//! 